/*
 * Copyright (C) 2011-2016 Markus Junginger, greenrobot (http://greenrobot.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.greenrobot.greendao;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.greenrobot.greendao.database.Database;

import ohos.app.Context;
import ohos.data.rdb.RdbException;
import ohos.data.rdb.RdbPredicates;
import ohos.data.rdb.RdbStore;
import ohos.data.resultset.ResultSet;

/** Database utils, for example to execute SQL scripts */
public class DbUtils {
    /**
     * Execute vaccum statement on database
     * @param db db to be operated on
     */
    public static void vacuum(Database db) {
        db.execSQL("VACUUM");
    }

    /**
     * Calls {@link # executeSqlScript(Context, Database, String, boolean)} with transactional set to true.
     *
     * @param context context
     * @param db database to work on
     * @param assetFilename asset file to be used
     * @return number of statements executed.
     * @throws IOException
     */
    public static int executeSqlScript(Context context, Database db, String assetFilename) throws IOException {
        return executeSqlScript(context, db, assetFilename, true);
    }

    /**
     * Executes the given SQL asset in the given database (SQL file should be UTF-8). The database file may contain
     * multiple SQL statements. Statements are split using a simple regular expression (something like
     * "semicolon before a line break"), not by analyzing the SQL syntax. This will work for many SQL files, but check
     * yours.
     *
     * @param context context
     * @param db database to work on
     * @param assetFilename asset file to be used
     * @param transactional if the operation s transactional
     * @return number of statements executed.
     * @throws IOException
     */
    public static int executeSqlScript(Context context, Database db, String assetFilename, boolean transactional)
            throws IOException {
        byte[] bytes = readAsset(context, assetFilename);
        String sql = new String(bytes, "UTF-8");
        String[] lines = sql.split(";(\\s)*[\n\r]");
        int count;
        if (transactional) {
            count = executeSqlStatementsInTx(db, lines);
        } else {
            count = executeSqlStatements(db, lines);
        }
        DaoLog.i("Executed " + count + " statements from SQL script '" + assetFilename + "'");
        return count;
    }

    /**
     * Executes these statements in transaction
     * @param db database to work on
     * @param statements statements to be executed
     * @return count of statements executed
     */
    public static int executeSqlStatementsInTx(Database db, String[] statements) {
        db.beginTransaction();
        try {
            int count = executeSqlStatements(db, statements);
            db.setTransactionSuccessful();
            return count;
        } finally {
            db.endTransaction();
        }
    }

    /**
     * Executes these statements
     * @param db database to work on
     * @param statements statements to be executed
     * @return count of the statements executed
     */
    public static int executeSqlStatements(Database db, String[] statements) {
        int count = 0;
        for (String line : statements) {
            line = line.trim();
            if (line.length() > 0) {
                db.execSQL(line);
                count++;
            }
        }
        return count;
    }

    /**
     * Copies all available data from in to out without closing any stream.
     *
     * @param in input strem to take data from,
     * @param out output stream to write data to
     * @return number of bytes copied
     * @throws IOException
     */
    public static int copyAllBytes(InputStream in, OutputStream out) throws IOException {
        int byteCount = 0;
        byte[] buffer = new byte[4096];
        while (true) {
            int read = in.read(buffer);
            if (read == -1) {
                break;
            }
            out.write(buffer, 0, read);
            byteCount += read;
        }
        return byteCount;
    }

    /**
     * Read all bytes from the input stream
     * @param in input stream to take data from
     * @return bytes read from input stream
     * @throws IOException
     */
    public static byte[] readAllBytes(InputStream in) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        copyAllBytes(in, out);
        return out.toByteArray();
    }

    /**
     * read data from asset file
     * @param context context
     * @param filename field to read asset from
     * @return data in byte array
     * @throws IOException ioexception
     */
    public static byte[] readAsset(Context context, String filename) throws IOException {
        InputStream in = context.getResourceManager().getRawFileEntry(filename).openRawFile();
        try {
            return readAllBytes(in);
        } finally {
            in.close();
        }
    }

    /**
     * Log the table dump
     * @param db database
     * @param tableName table name
     */
    public static void logTableDump(RdbStore db, String tableName) {
        ResultSet cursor = db.query(new RdbPredicates(tableName), null);
        try {
            String dump = dumpCursorToString(cursor);
            DaoLog.d(dump);
        } finally {
            cursor.close();
        }
    }

    /**
     * Dump cursor to string
     * @param cursor cursor to dump
     * @return string form of cursor
     */
    public static String dumpCursorToString(ResultSet cursor) {
        StringBuilder sb = new StringBuilder();
        dumpCursor(cursor, sb);
        return sb.toString();
    }

    /**
     * Dump cursor to a string builder
     * @param cursor cursor to be dumped
     * @param sb string builder
     */
    public static void dumpCursor(ResultSet cursor, StringBuilder sb) {
        sb.append(">>>>> Dumping cursor " + cursor + "\n");
        if (cursor != null) {
            int startPos = cursor.getRowIndex();
            cursor.goTo(-1);
            while (cursor.goToNextRow()) {
                dumpCurrentRow(cursor, sb);
            }
            cursor.goTo(startPos);
        }
        sb.append("<<<<<\n");
    }

    /**
     * Dump the current row of the cursor
     * @param cursor cursor to be dumped
     * @param sb string builder
     */
    public static void dumpCurrentRow(ResultSet cursor, StringBuilder sb) {
        String[] cols = cursor.getAllColumnNames();
        sb.append("" + cursor.getRowIndex() + " {\n");
        int length = cols.length;
        for (int i = 0; i < length; i++) {
                String value;
                try {
                        value = cursor.getString(i);
                    } catch (RdbException e) {
                        // assume that if the getString threw this exception then the column is not
                        // representable by a string, e.g. it is a BLOB.
                        value = "<unprintable>";
                    }
                sb.append("   " + cols[i] + '=' + value + "\n");
            }
        sb.append("}\n");
    }

}
